package com.macrounion.atv.service.entity;

import com.macrounion.base.service.entity.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;

/**
 * 设备表device
 * @author Administrator 2020-11-18
 */
@ApiModel(value = "设备表", description = "设备表")
public class Device extends BaseEntity implements Serializable {
    /**
     * 设备名
     */
    @ApiModelProperty(value = "设备名")
    private String name;

    /**
     * 设备id，通信识别码
     */
    @ApiModelProperty(value = "设备id，通信识别码")
    private String deviceCode;

    /**
     * 标识
     */
    @ApiModelProperty(value = "标识")
    private String flag;

    /**
     * 所属站点
     */
    @ApiModelProperty(value = "所属站点")
    private String spotId;

    /**
     * 协议类型
     */
    @ApiModelProperty(value = "协议类型")
    private String protocolId;

    /**
     * 0-实物设备，1-虚拟设备(虚拟设备没有协议类型)
     */
    @ApiModelProperty(value = "0-实物设备，1-虚拟设备(虚拟设备没有协议类型)")
    private Integer virtualType;

    /**
     * 0-上传所有通道数据，1-上传选择通道的数据
     */
    @ApiModelProperty(value = "0-上传所有通道数据，1-上传选择通道的数据")
    private Integer sendType;

    /**
     * 0-超时不报警,1-报警
     */
    @ApiModelProperty(value = "0-超时不报警,1-报警")
    private Integer channelTimeout;

    /**
     * 超时时间/min
     */
    @ApiModelProperty(value = "超时时间/min")
    private Integer timeout;

    /**
     * 备注
     */
    @ApiModelProperty(value = "备注")
    private String remark;

    /**
     * 0-超时，1正常
     */
    @ApiModelProperty(value = "0-超时，1正常")
    private Integer rstatus;

    /**
     * 0-不发送trap，1-发送(针对snmp协议设备)
     */
    @ApiModelProperty(value = "0-不发送trap，1-发送(针对snmp协议设备)")
    private Integer sendtrap;

    /**
     * device
     */
    private static final long serialVersionUID = 1L;

    /**
     * 设备名
     * @return 设备名
     */
    public String getName() {
        return name;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withName(String name) {
        this.setName(name);
        return this;
    }

    /**
     * 设备名
     * @param name 设备名
     */
    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    /**
     * 设备id，通信识别码
     * @return 设备id，通信识别码
     */
    public String getDeviceCode() {
        return deviceCode;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withDeviceCode(String deviceCode) {
        this.setDeviceCode(deviceCode);
        return this;
    }

    /**
     * 设备id，通信识别码
     * @param deviceCode 设备id，通信识别码
     */
    public void setDeviceCode(String deviceCode) {
        this.deviceCode = deviceCode == null ? null : deviceCode.trim();
    }


    /**
     * 标识
     * @return 标识
     */
    public String getFlag() {
        return flag;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withFlag(String flag) {
        this.setFlag(flag);
        return this;
    }

    /**
     * 标识
     * @param flag 标识
     */
    public void setFlag(String flag) {
        this.flag = flag == null ? null : flag.trim();
    }

    /**
     * 所属站点
     * @return 所属站点
     */
    public String getSpotId() {
        return spotId;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withSpotId(String spotId) {
        this.setSpotId(spotId);
        return this;
    }

    /**
     * 所属站点
     * @param spotId 所属站点
     */
    public void setSpotId(String spotId) {
        this.spotId = spotId == null ? null : spotId.trim();
    }

    /**
     * 协议类型
     * @return 协议类型
     */
    public String getProtocolId() {
        return protocolId;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withProtocolId(String protocolId) {
        this.setProtocolId(protocolId);
        return this;
    }

    /**
     * 协议类型
     * @param protocolId 协议类型
     */
    public void setProtocolId(String protocolId) {
        this.protocolId = protocolId == null ? null : protocolId.trim();
    }

    /**
     * 0-实物设备，1-虚拟设备(虚拟设备没有协议类型)
     * @return 0-实物设备，1-虚拟设备(虚拟设备没有协议类型)
     */
    public Integer getVirtualType() {
        return virtualType;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withVirtualType(Integer virtualType) {
        this.setVirtualType(virtualType);
        return this;
    }

    /**
     * 0-实物设备，1-虚拟设备(虚拟设备没有协议类型)
     * @param virtualType 0-实物设备，1-虚拟设备(虚拟设备没有协议类型)
     */
    public void setVirtualType(Integer virtualType) {
        this.virtualType = virtualType;
    }

    /**
     * 0-上传所有通道数据，1-上传选择通道的数据
     * @return 0-上传所有通道数据，1-上传选择通道的数据
     */
    public Integer getSendType() {
        return sendType;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withSendType(Integer sendType) {
        this.setSendType(sendType);
        return this;
    }

    /**
     * 0-上传所有通道数据，1-上传选择通道的数据
     * @param sendType 0-上传所有通道数据，1-上传选择通道的数据
     */
    public void setSendType(Integer sendType) {
        this.sendType = sendType;
    }

    /**
     * 0-超时不报警,1-报警
     * @return 0-超时不报警,1-报警
     */
    public Integer getChannelTimeout() {
        return channelTimeout;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withChannelTimeout(Integer channelTimeout) {
        this.setChannelTimeout(channelTimeout);
        return this;
    }

    /**
     * 0-超时不报警,1-报警
     * @param channelTimeout 0-超时不报警,1-报警
     */
    public void setChannelTimeout(Integer channelTimeout) {
        this.channelTimeout = channelTimeout;
    }

    /**
     * 超时时间/min
     * @return 超时时间/min
     */
    public Integer getTimeout() {
        return timeout;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withTimeout(Integer timeout) {
        this.setTimeout(timeout);
        return this;
    }

    /**
     * 超时时间/min
     * @param timeout 超时时间/min
     */
    public void setTimeout(Integer timeout) {
        this.timeout = timeout;
    }

    /**
     * 备注
     * @return 备注
     */
    public String getRemark() {
        return remark;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withRemark(String remark) {
        this.setRemark(remark);
        return this;
    }

    /**
     * 备注
     * @param remark 备注
     */
    public void setRemark(String remark) {
        this.remark = remark == null ? null : remark.trim();
    }

    /**
     * 0-超时，1正常
     * @return 0-超时，1正常
     */
    public Integer getRstatus() {
        return rstatus;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withRstatus(Integer rstatus) {
        this.setRstatus(rstatus);
        return this;
    }

    /**
     * 0-超时，1正常
     * @param rstatus 0-超时，1正常
     */
    public void setRstatus(Integer rstatus) {
        this.rstatus = rstatus;
    }

    /**
     * 0-不发送trap，1-发送(针对snmp协议设备)
     * @return 0-不发送trap，1-发送(针对snmp协议设备)
     */
    public Integer getSendtrap() {
        return sendtrap;
    }

    /**
     *
     * @mbg.generated
     */
    public Device withSendtrap(Integer sendtrap) {
        this.setSendtrap(sendtrap);
        return this;
    }

    /**
     * 0-不发送trap，1-发送(针对snmp协议设备)
     * @param sendtrap 0-不发送trap，1-发送(针对snmp协议设备)
     */
    public void setSendtrap(Integer sendtrap) {
        this.sendtrap = sendtrap;
    }

    /**
     *
     * @mbg.generated
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(getClass().getSimpleName());
        sb.append(" [");
        sb.append("Hash = ").append(hashCode());
        sb.append(", name=").append(name);
        sb.append(", deviceCode=").append(deviceCode);
        sb.append(", flag=").append(flag);
        sb.append(", spotId=").append(spotId);
        sb.append(", protocolId=").append(protocolId);
        sb.append(", virtualType=").append(virtualType);
        sb.append(", sendType=").append(sendType);
        sb.append(", channelTimeout=").append(channelTimeout);
        sb.append(", timeout=").append(timeout);
        sb.append(", remark=").append(remark);
        sb.append(", rstatus=").append(rstatus);
        sb.append(", sendtrap=").append(sendtrap);
        sb.append(", serialVersionUID=").append(serialVersionUID);
        sb.append("]");
        return sb.toString();
    }
}